// Go作者版权所有。版权所有。
// 此源代码的使用受BSD样式的约束
// 可以在许可证文件中找到的许可证。

package par

import "fmt"

// 队列管理一组并行执行的工作项。人数
// 活动工作项是有限的，多余的工作项按顺序排队。
type Queue struct {
	maxActive int
	st        chan queueState
}

type queueState struct {
	active  int // goroutine处理工作的数量；len（backlog）>0时始终非零
	backlog []func()
	idle    chan struct{} // 如果为非零，则在激活时关闭为0
}

// NewQueue返回最多并行执行maxActive项的队列。
// None
// maxActive必须为正。
func NewQueue(maxActive int) *Queue {
	if maxActive < 1 {
		panic(fmt.Sprintf("par.NewQueue called with nonpositive limit (%d)", maxActive))
	}

	q := &Queue{
		maxActive: maxActive,
		st:        make(chan queueState, 1),
	}
	q.st <- queueState{}
	return q
}

// 添加将f添加为队列中的工作项。
// None
// Add立即返回，但队列将在之后标记为非空闲
// f（以及任何随后添加的工作）已完成。
func (q *Queue) Add(f func()) {
	st := <-q.st
	if st.active == q.maxActive {
		st.backlog = append(st.backlog, f)
		q.st <- st
		return
	}
	if st.active == 0 {
		// 将q标记为非空闲。
		st.idle = nil
	}
	st.active++
	q.st <- st

	go func() {
		for {
			f()

			st := <-q.st
			if len(st.backlog) == 0 {
				if st.active--; st.active == 0 && st.idle != nil {
					close(st.idle)
				}
				q.st <- st
				return
			}
			f, st.backlog = st.backlog[0], st.backlog[1:]
			q.st <- st
		}
	}()
}

// Idle返回当q没有（活动或排队）时将关闭的通道
// 工作出色。
func (q *Queue) Idle() <-chan struct{} {
	st := <-q.st
	defer func() { q.st <- st }()

	if st.idle == nil {
		st.idle = make(chan struct{})
		if st.active == 0 {
			close(st.idle)
		}
	}

	return st.idle
}
